package com.atcumt.Write.writeStructures;

import java.util.LinkedHashMap;
import java.util.Map;

/* 
 * LRU 实现简化版 LinkedHashMap
 * LinkedHashMap是一个会按照put顺序，为key排序的的一个hash链表。
 * 在get时，如果命中缓存，将key删除重新put到链表尾部(moveToFirst)；
 * 在put时，如果命中缓存，将key删除再重新put到链表尾部(moveToFirst)，
 * 如果未命中且链表长度已满，删除链表头节点。新的数据插入链表尾部，旧的数据从链表头部删除
 */
public class LRUCache2 {
    private int capacity;
    private Map<Integer, Integer> map;

    public LRUCache2(int capacity) {
        this.capacity = capacity;
        map = new LinkedHashMap<>();
    }

    public int get(int key) {
        if (map.containsKey(key)) {
            moveToFirst(key);
            return map.get(key);
        } else {
            return -1;
        }
    }

    public void put(int key, int val) {
        if (map.containsKey(key)) {
            moveToFirst(key);
            map.put(key, val);
        } else {
            if (map.size() >= capacity) {
                map.remove(map.keySet().iterator().next());
            }
            map.put(key, val);
        }
    }


    private void moveToFirst(int key) {
        int val = map.remove(key);
        map.put(key, val);
    }

    public static void main(String[] args) {
        LRUCache2 lRUCache = new LRUCache2(2);
        lRUCache.put(1, 1); // 缓存是 {1=1}
        lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
        System.out.println(lRUCache.get(1)); // 1
        lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
        System.out.println(lRUCache.get(2)); // -1 (未找到)
        lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
        System.out.println(lRUCache.get(1)); // -1 (未找到)
        System.out.println(lRUCache.get(3)); // 3
        System.out.println(lRUCache.get(4)); // 4
    }
}
